Back to Main Menu

ESRI Integration via script

Introduction

A python script to integrate ArcGIS features with Assetic assets may be run outside of ArcGIS Desktop applications.  The script needs to be executed on a machine that has ArcGIS Desktop (or ArcGIS Server) installed because it utilises the arcpy python package installed by ArcGIS.  The arcpy library will also use an ESRI licence (lowest applicable licence) for the duration of the script execution.

 

The scripts also require the 'assetic_esri' package to be installed, as per the article ESRI Integration Introduction.

Scripted Process - New Feature Creation

This is a script that checks for features that do not have a corresponding asset in Assetic.  It creates an asset in Assetic for those features and updates the feature.  The script may be run periodically according to a schedule or manually initiated.

 

As an example the script may be run manually when all edits are complete and the spatial data edits have been committed.  Typically an 'asset Id' attribute field exists for the feature class that can be used to record the generated 'asset Id'.  The asset is created in Assetic, and the feature then updated to hold the 'asset Id'

Sample script - File Geodatabase

The sample script below may be copied and pasted to a text editor, and saved with a '.py' file extension. It is suggested that the script be saved as 'Assetic.CreateAssetsFromFileGDB'. This script example is for creating assets in Assetic where the source is a File Geodatabase.

 

  1. """
  2. Assetic.CreateAssetsFromFileGDB
  3. Sample script to create assets in Assetic corresponding with selected
  4. features from a file geodatabase
  5. """
  6. import assetic_esri
  7. import arcpy
  8.   
  9. # Define the feature class in the file geodatabase.  Could alternatively assign
  10. # a layer (.lyr)file
  11. lyr = arcpy.mapping.Layer(r'C:\Projects\assets.gdb\roads')
  12.   
  13. # Define file location for log and ini file with Assetic credentials and
  14. # integration configuration file
  15. inifile = r"c:\Assetic\assetic.ini"
  16. logfile = r"c:\Assetic\addin.log"
  17. xmlfile = r"c:\Assetic\arcmap_edit_config.xml"
  18. ae = assetic_esri.Initialise(xmlfile, inifile,  None,  "Info")
  19. tools = assetic_esri.LayerTools()
  20.   
  21. # define the query string for the layer we are adding
  22. where_clause =  "assetid is null"  # process fields where assetid is NULL
  23.   
  24. # clear any current selections and apply the new query.  Only features selected
  25. # by the query are processed
  26. arcpy.SelectLayerByAttribute_management(lyr,  "CLEAR_SELECTION")
  27. arcpy.SelectLayerByAttribute_management(lyr,  "NEW_SELECTION", where_clause)
  28.   
  29. # Now create assets in Assetic for the selected features
  30. tools.create_asset(lyr)

 

Sample script - Enterprise Geodatabase

The sample script below may be copied and pasted to a text editor, and saved with a '.py' file extension. It is suggested that the script be saved as 'Assetic.CreateAssetsFromLayers.py'. This script example is for creating assets in Assetic where the source is an Enterprise Geodatabase.

 

  1. """
  2. Assetic.CreateAssetsFromLayers.py
  3. Script to create assets in Assetic from features in one or more ArcGIS layers
  4. This example assumes a versioned enterprise geodatabase
  5. Requires asset_esri v1.0.1.4 or later
  6. """
  7. import arcpy
  8. import assetic_esri
  9. import os
  10.   
  11.   
  12. def main():
  13.   """
  14.     Initialise the assetic_esri library.  It will read the config files etc
  15.     """
  16.   if  not initasseticesri():
  17.   return
  18.   
  19.   # define layers to process (one or more), and the search query that
  20.   # identifies features to process as new assets
  21.     layers = list()
  22.   
  23.   # define the query string for the layer we are adding
  24.     query =  "assetid is null"  # process fields where assetid is NULL
  25.   # for testing, uncomment this line and specify a single record by id field
  26.   #query = "UFI = 'rds002720978'"
  27.   # add the layer to the list
  28.     layers.append(("C:\Projects/TAS/SealedRoads_sde.lyr",query))
  29.   
  30.   # more layers may be added using layers.append((layername, query)) format
  31.   
  32.   # loop through layer list and process new assets
  33.   for layer in layers:
  34.         create_assets_for_layername(layer[0],layer[1])
  35.   
  36.   
  37. def create_assets_for_layername(layername, query=None):
  38.   """
  39.     For the given layername and query filter process selected features
  40.     to create a corresponding asset in Assetic and update the feature with
  41.     the asset friendly asset id, or the assetic internal asset guid.
  42.     Versioned editing is assumed.  A new edit session is opened for the layer
  43.     edit
  44.     Assumes the xml config file has the layer name (as appears in the TOC)
  45.     :param layername: the file path and name of the layer file
  46.     :param query: optional, but if omitted all assets are processed.
  47.     example query strings:'assetid is null' or "externalid =  ''"
  48.     """
  49.   
  50.   # initialise assetic esri tools for layers
  51.     tools = assetic_esri.LayerTools()
  52.   
  53.   # get workspace
  54.     desc = arcpy.Describe(layername)
  55.     lyr =  None
  56.   if desc.dataType ==  "Layer":
  57.   # create an instance of the layer using the name
  58.         lyr = arcpy.mapping.Layer(layername)
  59.   else:
  60.   # need a layer
  61.   print("no layer defined")
  62.   return
  63.   
  64.   # get the workspace
  65.     arcpy.env.workspace = desc.Path
  66.   
  67.   # create edit session. If there is a workspace error try setting it to
  68.   # the folder containing the connection.  Make sure you also import os at
  69.   # the start.
  70.   # arcpy.env.workspace = os.path.dirname(desc.Path)
  71.     edit = arcpy.da.Editor(arcpy.env.workspace)
  72.   # start edit session
  73.     edit.startEditing(False,True)
  74.     edit.startOperation()
  75.   ##execute asset creation
  76.     tools.create_asset(lyr, query)
  77.   ##finalise
  78.     edit.stopOperation()
  79.     edit.stopEditing(True)
  80.   
  81.   
  82. def initasseticesri():
  83.   """
  84.     initialise the helper module assetic_esri
  85.     sets the paths to the xml config and ini files
  86.     """
  87.     appdata = os.environ.get("APPDATA")
  88.     inifile = os.path.abspath(appdata +  "\\Assetic\\assetic.ini")
  89.     logfile = os.path.abspath(appdata +  "\\Assetic\\addin.log")
  90.     xmlfile = os.path.abspath(appdata +  "\\Assetic\\arcmap_edit_config.xml")
  91.   try:
  92.         ae = assetic_esri.Initialise(xmlfile,inifile,logfile,"Info")
  93.   except  Exception  as ex:
  94.   print("Error initialising Addin: {0}".format(ex))
  95.   return  False
  96.   return  True
  97.   
  98.   
  99. if __name__ ==  "__main__":
  100.     main()

Alternatively download the file: Assetic.CreateAssetsFromLayers.py

 

How it works

The script uses ESRI layer files to define the data source to integrate.  A query string is used to filter the records in the layer file to select the features that are new i.e. do not have a value in the 'assetid' field.

  #for the layer we are adding, define the query string     query =  "assetid is null"  #process fields where assetid is NULL  #for testing, uncomment this line and specify a single record by id field  #query = "UFI = 'rds002720978'"  #add the layer to the list     layers.append(("C:\Projects\TAS\SealedRoads_sde.lyr",query))  #more layers may be added using layers.append((layername, query)) format

In the example above, the layer file is  "C:\Projects\TAS\SealedRoads_sde.lyr", and the query filter is "assetid is null".  Change these two settings in the script to suit your dataset and the script is ready to run (assuming the XML configuration file and assetic.ini configuration file are also configured).

 

Asset Updates via Assetic

Where Assetic is the master for asset attributes, ArcMap needs a simple way to reference the attributes.  This is managed by the Assetic Python SDK tool Creating-a-Local-Backup-of-Assetic-Data-Assetic-Python-SDK-.  This tool will ensure that a local copy of the attributes needed within ArcMap are available.  There is no need to update the features with the attributes, a database join is sufficient. 

 

Scripted Process - Feature Edits

As with 'New Features' a python script may be run that updates Assetic with attribute values updated in ArcMap.

 

Where such a script is implemented, it is treating ArcMap as the 'master' data source for those particular assets.  This kind of integration is not without risk because individual fields within Assetic cannot be set as read-only, so it is possible another user has also updated those same fields via the Assetic application itself.

 

It may also be difficult to identify which features have changed (outside of the edit session itself), and will be dependent on site specific workflows.

 

Some options for identifying edited features are:

  • Use of archiving is one way to detect changes
  • Use an additional attribute field that can be used to flag the edit - 'last modified date' is a typical example.  'last modified date' can be enforced for Datasets via 'Editor Tracking

 

If the edit occurs in a different geodatabase to the 'publishing' geodatabase, and the sync with Assetic is to be actioned when the edits are published to the 'publishing' geodatabase the arcpy function arcpy.DetectFeatureChanges_management() may be used to detect changes prior to publishing.

Scripted Process - Feature Deletes

For features that are deleted, archived, or flagged as decommisioned the same integration logic as for feature edits is applied.   For these features a field in Assetic would be updated to indicate the new status.   It is suggested the following Assetic fields ("Management"-."Operational Details") can be used to flag this status:

  • Decommissioned Date
  • Asset Disposal
  • Operational State

This then allows the assets to be identified within Assetic, and for the appropriate work flow to then take place in Assetic.